// // MeshManager.ts
// import * as BABYLON from '@babylonjs/core';

// export class MeshManager {
//   private static ASSETS_MANAGER: BABYLON.AssetsManager;
//   private static ASSETS_CONTAINER: BABYLON.AssetContainer;
//   private static SCENE: BABYLON.Scene;

//   public static initialize(engine: BABYLON.Engine, rootUrl: string, resources: string[]): BABYLON.MeshAssetTask[] {
//     if (!MeshManager.SCENE) {
//       return [];
//     }

//     MeshManager.SCENE = new BABYLON.Scene(engine);
//     MeshManager.ASSETS_MANAGER = new BABYLON.AssetsManager(MeshManager.SCENE);
//     var tasks = [];
//     for (var resource of resources) {
//       var task = MeshManager.ASSETS_MANAGER.addMeshTask(resource, '', rootUrl, resource);
//       tasks.push(task);
//     }

//     MeshManager.ASSETS_MANAGER.addContainerTask('container', '', rootUrl, 'container');
//     return tasks;
//   }

//   /**
//    * 预加载所有资源
//    * @param progressCallback 加载进度回调函数
//    * @returns 所有资源加载完成的 Promise
//    */
//   public static preloadAllResources(
//     progressCallback?: (loadedCount: number, totalCount: number) => void,
//   ): Promise<void[]> {
//     const promises: Promise<void>[] = [];
//     const totalCount = this._resourcePaths.size;
//     let loadedCount = 0;

//     this._resourcePaths.forEach((path, name) => {
//       const promise = this._loadResource(name, path).then(() => {
//         loadedCount++;
//         if (progressCallback) {
//           progressCallback(loadedCount, totalCount);
//         }
//       });
//       promises.push(promise);
//     });

//     return Promise.all(promises);
//   }

//   /**
//    * 获取模型实例
//    * 如果模型已加载，则创建并返回实例
//    * 如果模型未加载，则开始加载并在加载完成后创建实例
//    * @param name 模型名称
//    * @returns 模型实例的网格数组
//    */
//   public static async getModelInstance(name: string): Promise<BABYLON.AbstractMesh[]> {
//     const path = this._resourcePaths.get(name);

//     if (!path) {
//       throw new Error(`资源不存在: ${name}`);
//     }

//     // 确保资源已加载
//     await this._ensureResourceLoaded(name);

//     // 创建模型实例
//     return this._createModelInstance(name);
//   }

//   /**
//    * 加载并显示场景
//    * @param name 场景名称
//    * @param clearScene 是否清除当前场景
//    * @returns 加载完成的场景
//    */
//   public static async loadScene(name: string, clearScene: boolean = false): Promise<BABYLON.Scene> {
//     const path = this._resourcePaths.get(name);

//     if (!path) {
//       throw new Error(`资源不存在: ${name}`);
//     }

//     // 确保资源已加载
//     await this._ensureResourceLoaded(name);

//     // 显示场景
//     return this._showScene(name, clearScene);
//   }

//   /**
//    * 检查资源是否已加载
//    * @param name 资源名称
//    * @returns 是否已加载
//    */
//   public static hasResource(name: string): boolean {
//     return this._assetContainers.has(name);
//   }

//   /**
//    * 从场景中移除模型实例
//    * @param meshes 模型实例的网格数组
//    */
//   public static removeModelInstance(meshes: BABYLON.AbstractMesh[]): void {
//     meshes.forEach((mesh) => {
//       mesh.setEnabled(false);
//       mesh.isVisible = false;
//     });
//   }

//   /**
//    * 从场景和缓存中完全删除资源
//    * @param name 资源名称
//    */
//   public static deleteResource(name: string): void {
//     const container = this._assetContainers.get(name);

//     if (container) {
//       container.dispose();
//       this._assetContainers.delete(name);
//     }
//   }

//   /**
//    * 确保资源已加载
//    * @param name 资源名称
//    */
//   private static async _ensureResourceLoaded(name: string): Promise<void> {
//     if (this.hasResource(name)) {
//       return;
//     }

//     const path = this._resourcePaths.get(name);

//     if (!path) {
//       throw new Error(`资源不存在: ${name}`);
//     }

//     // 如果资源正在加载，等待加载完成
//     if (this._loadingPromises.has(name)) {
//       await this._loadingPromises.get(name)!;
//       return;
//     }

//     // 开始加载资源
//     const loadPromise = this._loadResource(name, path);
//     this._loadingPromises.set(name, loadPromise);

//     try {
//       await loadPromise;
//     } finally {
//       this._loadingPromises.delete(name);
//     }
//   }

//   /**
//    * 加载资源的私有方法
//    * @param name 资源名称
//    * @param path 资源路径
//    * @returns 加载完成的 Promise
//    */
//   private static async _loadResource(name: string, path: string): Promise<void> {
//     var result = await BABYLON.ImportMeshAsync(path, this._scene);
//     if (result) {
//     }
//     return new Promise((resolve, reject) => {
//       console.log(`开始加载资源: ${name} (${path})`);

//       const assetManager = new BABYLON.AssetsManager(this._scene);
//       var task = assetManager.addMeshTask('meshTask', '', path, '');
//       task.loadedMeshes;

//       // 使用 AssetContainer 构造函数直接加载资源
//       const container = new BABYLON.AssetContainer(this._scene);
//       container.addAllToScene();

//       // 提取路径中的文件夹和文件名
//       const pathParts = path.split('/');
//       const fileName = pathParts.pop() || '';
//       const rootUrl = pathParts.join('/') + '/';

//       container.load(
//         rootUrl,
//         fileName,
//         () => {
//           // 默认禁用所有网格
//           container.meshes.forEach((mesh) => {
//             mesh.setEnabled(false);
//             mesh.isVisible = false;
//           });

//           // 存储 AssetContainer
//           this._assetContainers.set(name, container);

//           console.log(`资源加载成功: ${name}`);
//           resolve();
//         },
//         undefined,
//         (message) => {
//           console.error(`资源加载错误: ${name}`, message);
//           container.dispose(); // 清理不完整的 AssetContainer
//           reject(new Error(`资源加载错误: ${name}, ${message}`));
//         },
//       );
//     });
//   }

//   /**
//    * 创建模型实例的私有方法
//    * @param name 模型名称
//    * @returns 模型实例的网格数组
//    */
//   private static _createModelInstance(name: string): BABYLON.AbstractMesh[] {
//     const container = this._assetContainers.get(name)!;
//     const instanceMeshes: BABYLON.AbstractMesh[] = [];

//     // 克隆所有网格
//     container.meshes.forEach((originalMesh) => {
//       if (originalMesh.name !== '__root__') {
//         // 跳过根节点
//         const instance = originalMesh.clone(`${name}_${originalMesh.name}`);
//         if (instance) {
//           instance.setEnabled(true);
//           instance.isVisible = true;
//           instanceMeshes.push(instance);
//         }
//       }
//     });

//     // 克隆所有骨骼和动画组
//     container.skeletons.forEach((skeleton) => {
//       const clonedSkeleton = skeleton.clone(`${name}_${skeleton.name}`);
//       // 绑定骨骼到相应的网格
//     });

//     container.animationGroups.forEach((animationGroup) => {
//       const clonedGroup = animationGroup.clone(`${name}_${animationGroup.name}`);
//       // 调整动画组的目标
//     });

//     return instanceMeshes;
//   }

//   /**
//    * 显示场景的私有方法
//    * @param name 场景名称
//    * @param clearScene 是否清除当前场景
//    * @returns 场景引用
//    */
//   private static _showScene(name: string, clearScene: boolean): BABYLON.Scene {
//     const container = this._assetContainers.get(name)!;

//     if (clearScene) {
//       // 清除当前场景中的所有网格
//       this._scene.meshes.forEach((mesh) => {
//         if (!mesh.isRootMesh) {
//           mesh.dispose();
//         }
//       });

//       // 将 AssetContainer 中的所有内容添加到场景
//       container.addAllToScene();

//       // 启用所有网格
//       container.meshes.forEach((mesh) => {
//         mesh.setEnabled(true);
//         mesh.isVisible = true;
//       });
//     } else {
//       // 直接启用所有网格
//       container.meshes.forEach((mesh) => {
//         mesh.setEnabled(true);
//         mesh.isVisible = true;
//       });
//     }

//     return this._scene;
//   }
// }
